package com.jd.service.impl;


import com.jd.bo.SubmitOrderBO;
import com.jd.enums.OrderStatusEnum;
import com.jd.enums.YesOrNo;
import com.jd.mapper.CarouselMapper;
import com.jd.mapper.OrderItemsMapper;
import com.jd.mapper.OrderMapper;
import com.jd.mapper.OrderStatusMapper;
import com.jd.pojo.*;
import com.jd.service.AddressService;
import com.jd.service.CarouselService;
import com.jd.service.ItemService;
import com.jd.service.OrderService;
import com.jd.utils.DateUtil;
import com.jd.vo.MerchantOrdersVO;
import com.jd.vo.OrderVO;
import org.n3r.idworker.Sid;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import tk.mybatis.mapper.entity.Example;

import java.util.Date;
import java.util.List;

/**
 * order业务层
 */
@Service
public class OrderServiceImpl implements OrderService{

    @Autowired
    private OrderMapper orderMapper;


    @Autowired
    private OrderItemsMapper orderItemsMapper;

    @Autowired
    private OrderStatusMapper orderStatusMapper;


    @Autowired
    private AddressService addressService;

    @Autowired
    private ItemService itemService;

    @Autowired
    private Sid sid;


    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public OrderVO createOrder(SubmitOrderBO submitOrderBO) {
        String userId=submitOrderBO.getUserId();
        String addressId=submitOrderBO.getAddressId();
        String itemSpecIds=submitOrderBO.getItemSpecIds();
        Integer payMethod=submitOrderBO.getPayMethod();
        String  leftMsg=submitOrderBO.getLeftMsg();
        //包邮费用设置为0
        Integer postAmount=0;

        String orderId=sid.nextShort();
        UserAddress address=addressService.queryUserAddress(userId,addressId);


        //1、 新订单数据保存
        Order newOrder=new Order();
        newOrder.setId(orderId);
        newOrder.setUserId(userId);
        //订单地址信息
        newOrder.setReceiverName(address.getReceiver());
        newOrder.setReceiverMobile(address.getMobile());
        newOrder.setReceiverAddress(address.getProvince()+" "+address.getCity()+" "+
                address.getDistrict()+" "+address.getDetail());


        newOrder.setPostAmount(postAmount);
        newOrder.setPayMethod(payMethod);
        newOrder.setLeftMsg(leftMsg);
        newOrder.setIsComment(YesOrNo.NO.type);
        newOrder.setIsDelete(YesOrNo.NO.type);
        newOrder.setCreatedTime(new Date());
        newOrder.setUpdatedTime(new Date());


        //2、 循环根据itemSpecIds保存订单商品信息表
        String itemSpecIdArr[]=itemSpecIds.split(",");
        Integer totalAmount=0;      //商品原价累积
        Integer realPayAmount=0;    //优惠后的实际价格累积
        for(String itemSpecId:itemSpecIdArr){
            //TODO 整合redis后，商品的购买的数量重新从redis的购物车中获取
            int buyCounts=1;

            // 2.1 根据规格id，查询规格的具体信息，只要获取价格
            ItemsSpec itemsSpec=itemService.queryItemSpecById(itemSpecId);
            totalAmount+=itemsSpec.getPriceNormal()*buyCounts;
            realPayAmount+=itemsSpec.getPriceDiscount()*buyCounts;

            //2.2 根据规格id，获得商品信息以及商品图片
            String itemId=itemsSpec.getItemId();
            Item item =itemService.queryItemById(itemId);
            String imgUrl=itemService.queryItemMainImgById(itemId);

            //2.3  循环保存子订单数据到数据库
            OrderItems subOrderItem=new OrderItems();
            String subOrderId=sid.nextShort();
            subOrderItem.setId(subOrderId);
            subOrderItem.setOrderId(orderId);
            subOrderItem.setItemId(itemId);
            subOrderItem.setItemName(item.getItemName());
            subOrderItem.setItemImg(imgUrl);
            subOrderItem.setBuyCounts(buyCounts);
            subOrderItem.setItemSpecId(itemSpecId);
            subOrderItem.setItemSpecName(itemsSpec.getName());
            subOrderItem.setPrice(itemsSpec.getPriceDiscount());
            orderItemsMapper.insert(subOrderItem);

            //2.4 在用户提交订单以后，规格表中要扣除库存
            itemService.deceaseItemSpecStock(itemSpecId,buyCounts);

        }

        newOrder.setTotalAmount(totalAmount);
        newOrder.setRealPayAmount(realPayAmount);
        orderMapper.insert(newOrder);
        //3、保存订单状态表
        OrderStatus waitPayOrderStats=new OrderStatus();
        waitPayOrderStats.setOrderId(orderId);
        waitPayOrderStats.setOrderStatus(OrderStatusEnum.WAIT_PAY.type);
        waitPayOrderStats.setCreatedTime(new Date());
        orderStatusMapper.insert(waitPayOrderStats);


        //4、构建商户订单，用于
        MerchantOrdersVO merchantOrdersVO=new MerchantOrdersVO();
        merchantOrdersVO.setMerchantOrderId(orderId);
        merchantOrdersVO.setMerchantUserId(userId);
        merchantOrdersVO.setAmount(realPayAmount+postAmount);
        merchantOrdersVO.setPayMethod(payMethod);

        //
        OrderVO orderVO=new OrderVO();
        orderVO.setOrderId(orderId);
        orderVO.setMerchantOrdersVO(merchantOrdersVO);
        return orderVO;
    }

    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void updateOrderStatus(String orderId, Integer orderStatus) {
        OrderStatus   paidStatus=new OrderStatus();
        paidStatus.setOrderId(orderId);
        paidStatus.setOrderStatus(orderStatus);
        paidStatus.setPayTime(new Date());
        orderStatusMapper.updateByPrimaryKeySelective(paidStatus);
    }

    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public OrderStatus queryOrderStatusInfo(String orderId) {
        return orderStatusMapper.selectByPrimaryKey(orderId);
    }

    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void closeOrder() {
        //查询所有未付款订单，判断时间是否超时（1天）
        OrderStatus queryOrder=new OrderStatus();
        queryOrder.setOrderStatus(OrderStatusEnum.WAIT_PAY.type);
        List<OrderStatus> list=orderStatusMapper.select(queryOrder);
        for(OrderStatus os:list){
            //获得订单创建时间
            Date createdTime=os.getCreatedTime();
            //和当前时间对比
            int days=DateUtil.daysBetween(createdTime,new Date());
            if(days>=1){
                //超过1天，关闭订单
                doCloseOrder(os.getOrderId());
            }
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    void doCloseOrder(String orderId){
        OrderStatus close=new OrderStatus();
        close.setOrderId(orderId);
        close.setOrderStatus(OrderStatusEnum.CLOSE.type);
        close.setCloseTime(new Date());
        orderStatusMapper.updateByPrimaryKeySelective(close);
    }
}




